ഫ്രണ്ടെൻഡ് മോണോറെപ്പോ: ലേർണയും എൻഎക്സ് വർക്ക്സ്പേസ് മാനേജ്മെൻ്റും

ഫ്രണ്ടെൻഡ് ഡെവലപ്‌മെൻ്റിൻ്റെ എക്കാലത്തും വികസിച്ചുകൊണ്ടിരിക്കുന്ന ലാൻഡ്‌സ്‌കേപ്പിൽ, വലുതും സങ്കീർണ്ണവുമായ പ്രോജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നത് ഒരു പ്രധാന വെല്ലുവിളിയാണ്. പരമ്പരാഗത മൾട്ടി-റെപ്പോ സെറ്റപ്പുകൾ, ഒറ്റപ്പെടൽ വാഗ്ദാനം ചെയ്യുമ്പോൾ തന്നെ, കോഡ് ഡ്യൂപ്ലിക്കേഷനിലേക്കും, ഡിപ്പൻഡൻസി മാനേജ്മെൻ്റ് തലവേദനകളിലേക്കും, സ്ഥിരതയില്ലാത്ത ടൂളിംഗിലേക്കും നയിച്ചേക്കാം. ഇവിടെയാണ് മോണോറെപ്പോ ആർക്കിടെക്ചർ തിളങ്ങുന്നത്. ഒരു മോണോറെപ്പോ എന്നത് ഒരേസമയം നിർമ്മിക്കുകയും പതിപ്പ് നൽകുകയും ചെയ്യുന്ന ഒന്നിലധികം പ്രോജക്റ്റുകൾ അടങ്ങിയ ഒരൊറ്റ ശേഖരണമാണ്. ഈ സമീപനം നിരവധി നേട്ടങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, എന്നാൽ ഒരു മോണോറെപ്പോയെ ഫലപ്രദമായി കൈകാര്യം ചെയ്യാൻ പ്രത്യേക ഉപകരണങ്ങൾ ആവശ്യമാണ്. ഈ ലേഖനം രണ്ട് ജനപ്രിയ പരിഹാരങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നു: ലേർണയും എൻഎക്സും.

എന്താണ് ഒരു മോണോറെപ്പോ?

ഒരു മോണോറെപ്പോ എന്നത് നിരവധി പ്രോജക്റ്റുകൾക്കായുള്ള കോഡ് ഉൾക്കൊള്ളുന്ന ഒരു പതിപ്പ് നിയന്ത്രണ സിസ്റ്റം ശേഖരണമാണ്. ഈ പ്രോജക്റ്റുകൾ പരസ്പരം ബന്ധപ്പെട്ടതോ പൂർണ്ണമായും സ്വതന്ത്രമോ ആകാം. പ്രധാന കാര്യം അവ ഒരേ ശേഖരം പങ്കിടുന്നു എന്നതാണ്. Google, Facebook, Microsoft, Uber തുടങ്ങിയ കമ്പനികൾ അവരുടെ വലിയ കോഡ്ബേസുകൾ കൈകാര്യം ചെയ്യാൻ മോണോറെപ്പോകൾ വിജയകരമായി സ്വീകരിച്ചു. Android, Chrome, Gmail എന്നിവയുൾപ്പെടെ Google അവരുടെ കോഡുകളെല്ലാം ഒരൊറ്റ ശേഖരണത്തിൽ സൂക്ഷിക്കുന്നതിനെക്കുറിച്ച് ചിന്തിക്കുക.

ഒരു മോണോറെപ്പോയുടെ ഗുണങ്ങൾ

• കോഡ് പങ്കിടലും വീണ്ടും ഉപയോഗിക്കലും: സങ്കീർണ്ണമായ പാക്കേജിംഗും പ്രസിദ്ധീകരണ പ്രവർത്തനങ്ങളുമില്ലാതെ തന്നെ പ്രോജക്റ്റുകൾക്കിടയിൽ കോഡ് എളുപ്പത്തിൽ പങ്കിടുക. ഒരേ ശേഖരണത്തിനുള്ളിൽ ഒന്നിലധികം ആപ്ലിക്കേഷനുകളിലേക്ക് തടസ്സമില്ലാതെ സംയോജിപ്പിക്കാൻ കഴിയുന്ന ഒരു ഡിസൈൻ സിസ്റ്റം ലൈബ്രറി സങ്കൽപ്പിക്കുക.
• ലളിതമായ ഡിപ്പൻഡൻസി മാനേജ്മെൻ്റ്: എല്ലാ പ്രോജക്റ്റുകളിലും സ്ഥിരത ഉറപ്പാക്കിക്കൊണ്ട് ഒരിടത്ത് ഡിപ്പൻഡൻസികൾ കൈകാര്യം ചെയ്യുക. ഒരു പങ്കിട്ട ലൈബ്രറിയുടെ ഡിപ്പൻഡൻസി അപ്‌ഡേറ്റ് ചെയ്യുന്നത് അതിനെ ആശ്രയിക്കുന്ന എല്ലാ പ്രോജക്റ്റുകളെയും സ്വയമേവ അപ്‌ഡേറ്റ് ചെയ്യും.
• ആറ്റോമിക് മാറ്റങ്ങൾ: ഒരൊറ്റ കമ്മിറ്റിൽ ഒന്നിലധികം പ്രോജക്റ്റുകളിൽ വ്യാപിച്ചു കിടക്കുന്ന മാറ്റങ്ങൾ വരുത്തുക, സ്ഥിരത ഉറപ്പാക്കുക, കൂടാതെ ടെസ്റ്റിംഗ് ലളിതമാക്കുക. ഉദാഹരണത്തിന്, ഫ്രണ്ടെൻഡിനെയും ബാക്കെൻഡിനെയും ബാധിക്കുന്ന ഒരു റീഫാക്ടറിംഗ് ആറ്റോമിക് ആയി ചെയ്യാൻ കഴിയും.
• മെച്ചപ്പെട്ട സഹകരണം: ടീമുകൾക്ക് ഒരേ ശേഖരണത്തിനുള്ളിൽ വ്യത്യസ്ത പ്രോജക്റ്റുകളിൽ എളുപ്പത്തിൽ സഹകരിക്കാനും, അറിവ് പങ്കിടാനും, ക്രോസ്-ഫങ്ഷണൽ ഡെവലപ്മെൻ്റ് പ്രോത്സാഹിപ്പിക്കാനും കഴിയും. ഡെവലപ്പർമാർക്ക് വ്യത്യസ്ത ടീമുകളിലുടനീളമുള്ള കോഡ് എളുപ്പത്തിൽ ബ്രൗസ് ചെയ്യാനും മനസ്സിലാക്കാനും കഴിയും.
• സ്ഥിരമായ ടൂളിംഗും രീതികളും: എല്ലാ പ്രോജക്റ്റുകളിലും സ്ഥിരമായ കോഡിംഗ് നിലവാരം, ലിൻ്റിംഗ് നിയമങ്ങൾ, നിർമ്മാണ പ്രക്രിയകൾ എന്നിവ നടപ്പിലാക്കുക. ഇത് കോഡിൻ്റെ ഗുണനിലവാരവും പരിപാലനക്ഷമതയും മെച്ചപ്പെടുത്തുന്നു.
• ലളിതമായ റീഫാക്ടറിംഗ്: വലിയ തോതിലുള്ള റീഫാക്ടറിംഗ് പ്രോജക്റ്റുകൾ ലളിതമാക്കുന്നു, കാരണം ബന്ധപ്പെട്ട എല്ലാ കോഡുകളും ഒരേ ശേഖരണത്തിനുള്ളിലാണ്. ഓട്ടോമേറ്റഡ് റീഫാക്ടറിംഗ് ടൂളുകൾ കോഡ്ബേസിൽ ഉടനീളം ഉപയോഗിക്കാൻ കഴിയും.

ഒരു മോണോറെപ്പോയുടെ വെല്ലുവിളികൾ

• ശേഖരണത്തിൻ്റെ വലുപ്പം: മോണോറെപ്പോകൾ വളരെ വലുതായി മാറിയേക്കാം, ഇത് ക്ലോണിംഗും ഇൻഡെക്സിംഗ് പ്രവർത്തനങ്ങളും മന്ദഗതിയിലാക്കാൻ സാധ്യതയുണ്ട്. `git sparse-checkout`, `partial clone` പോലുള്ള ടൂളുകൾക്ക് ഈ പ്രശ്നം ലഘൂകരിക്കാൻ സഹായിക്കും.
• നിർമ്മാണ സമയങ്ങൾ: വലിയ പ്രോജക്റ്റുകൾക്ക് മുഴുവൻ മോണോറെപ്പോയും നിർമ്മിക്കാൻ സമയമെടുക്കും. ലേർണയും എൻഎക്സും ഇത് പരിഹരിക്കാൻ ഒപ്റ്റിമൈസ് ചെയ്ത നിർമ്മാണ പ്രക്രിയകൾ വാഗ്ദാനം ചെയ്യുന്നു.
• ആക്സസ്സ് നിയന്ത്രണം: മോണോറെപ്പോയുടെ ചില ഭാഗങ്ങളിലേക്കുള്ള ആക്സസ്സ് നിയന്ത്രിക്കുന്നത് സങ്കീർണ്ണമാക്കാം. ആക്സസ്സ് നിയന്ത്രണ സംവിധാനങ്ങളുടെ ശ്രദ്ധാപൂർവ്വമായ ആസൂത്രണവും നടപ്പാക്കലും ആവശ്യമാണ്.
• ടൂളിംഗ് സങ്കീർണ്ണത: ഒരു മോണോറെപ്പോ സജ്ജീകരിക്കുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനും പ്രത്യേക ടൂളിംഗും അറിവും ആവശ്യമാണ്. പഠനരീതി തുടക്കത്തിൽ കുത്തനെയുള്ളതാകാം.

ലേർണ: ഒരു മോണോറെപ്പോയിൽ JavaScript പ്രോജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നു

ഒരു മോണോറെപ്പോയിൽ JavaScript പ്രോജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു ജനപ്രിയ ഉപകരണമാണ് ലേർണ. Git, npm എന്നിവ ഉപയോഗിച്ച് മൾട്ടി-പാക്കേജ് ശേഖരണങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള വർക്ക്ഫ്ലോ ഇത് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു. ഡിപ്പൻഡൻസി മാനേജ്മെൻ്റിനായി npm അല്ലെങ്കിൽ Yarn ഉപയോഗിക്കുന്ന പ്രോജക്റ്റുകൾക്ക് ഇത് വളരെ അനുയോജ്യമാണ്.

ലേർണയുടെ പ്രധാന സവിശേഷതകൾ

• പതിപ്പ് മാനേജ്മെൻ്റ്: അവസാന റിലീസിന് ശേഷം വരുത്തിയ മാറ്റങ്ങളെ അടിസ്ഥാനമാക്കി ലേർണയ്ക്ക് പാക്കേജുകൾ സ്വയമേവ പതിപ്പ് നൽകാനും പ്രസിദ്ധീകരിക്കാനും കഴിയും. അടുത്ത പതിപ്പ് നമ്പർ നിർണ്ണയിക്കാൻ ഇത് പരമ്പരാഗത കമ്മിറ്റുകൾ ഉപയോഗിക്കുന്നു.
• ഡിപ്പൻഡൻസി മാനേജ്മെൻ്റ്: മോണോറെപ്പോയ്ക്കുള്ളിലെ പാക്കേജുകൾക്ക് പരസ്പരം ആശ്രയിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് ലേർണ ഇൻ്റർ-പാക്കേജ് ഡിപ്പൻഡൻസികൾ കൈകാര്യം ചെയ്യുന്നു. പ്രാദേശിക ഡിപ്പൻഡൻസികൾ സൃഷ്ടിക്കാൻ ഇത് സിംലിങ്കിംഗ് ഉപയോഗിക്കുന്നു.
• ടാസ്ക് എക്സിക്യൂഷൻ: ലേർണയ്ക്ക് ഒന്നിലധികം പാക്കേജുകളിൽ കമാൻഡുകൾ സമാന്തരമായി എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും, ഇത് നിർമ്മാണവും ടെസ്റ്റിംഗ് പ്രക്രിയകളും വേഗത്തിലാക്കുന്നു. ഇത് `package.json`-ൽ നിർവചിച്ചിട്ടുള്ള സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കാൻ പിന്തുണയ്ക്കുന്നു.
• മാറ്റം കണ്ടെത്തൽ: അവസാന റിലീസിന് ശേഷം ഏതൊക്കെ പാക്കേജുകൾ മാറിയെന്ന് ലേർണയ്ക്ക് കണ്ടെത്താനാകും, ഇത് ലക്ഷ്യമിട്ടുള്ള നിർമ്മാണങ്ങൾക്കും വിന്യാസങ്ങൾക്കും അനുവദിക്കുന്നു.

ലേർണ ഉപയോഗത്തിനുള്ള ഉദാഹരണം

ലളിതമായ ഒരു ഉദാഹരണത്തിലൂടെ ലേർണയുടെ ഉപയോഗം നമുക്ക് ചിത്രീകരിക്കാം. നമുക്ക് രണ്ട് പാക്കേജുകളുള്ള ഒരു മോണോറെപ്പോ ഉണ്ടെന്ന് കരുതുക: `package-a`, `package-b`. `package-b` എന്നത് `package-a`-യെ ആശ്രയിച്ചിരിക്കുന്നു.

monorepo/
├── lerna.json
├── package.json
├── packages/
│   ├── package-a/
│   │   ├── package.json
│   │   └── index.js
│   └── package-b/
│       ├── package.json
│       └── index.js

1. ലേർണ ആരംഭിക്കുക:

lerna init

ഇത് `lerna.json` ഉണ്ടാക്കുകയും റൂട്ട് `package.json` അപ്‌ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു. `lerna.json` ഫയൽ ലേർണയുടെ സ്വഭാവം ക്രമീകരിക്കുന്നു.

2. ഡിപ്പൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുക:

npm install
# അല്ലെങ്കിൽ
yarn install

ഓരോ പാക്കേജിലെയും `package.json` ഫയലുകളെ അടിസ്ഥാനമാക്കി ഇത് മോണോറെപ്പോയിലെ എല്ലാ പാക്കേജുകൾക്കുമുള്ള ഡിപ്പൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു.

3. പാക്കേജുകളിൽ ഉടനീളം ഒരു കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

lerna run test

ഇത് നിർവചിച്ചിട്ടുള്ള എല്ലാ പാക്കേജുകളുടെയും `package.json` ഫയലുകളിൽ നിർവചിച്ചിട്ടുള്ള `test` സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നു.

4. പാക്കേജുകൾ പ്രസിദ്ധീകരിക്കുക:

lerna publish

ഈ കമാൻഡ് കമ്മിറ്റ് ഹിസ്റ്ററി വിശകലനം ചെയ്യുകയും, ഏതൊക്കെ പാക്കേജുകൾ മാറിയെന്ന് നിർണ്ണയിക്കുകയും, പരമ്പരാഗത കമ്മിറ്റുകളെ അടിസ്ഥാനമാക്കി അവയുടെ പതിപ്പുകൾ ഉയർത്തുകയും, അവയെ npm-ലേക്ക് (അല്ലെങ്കിൽ നിങ്ങൾ തിരഞ്ഞെടുത്ത രജിസ്ട്രിയിലേക്ക്) പ്രസിദ്ധീകരിക്കുകയും ചെയ്യുന്നു.

ലേർണ കോൺഫിഗറേഷൻ

`lerna.json` ഫയലാണ് ലേർണയുടെ കോൺഫിഗറേഷന്റെ ഹൃദയം. ഇത് ലേർണയുടെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു:

• `packages`: മോണോറെപ്പോയ്ക്കുള്ളിലെ പാക്കേജുകളുടെ സ്ഥാനം വ്യക്തമാക്കുന്നു. പലപ്പോഴും `["packages/*"]`-ൽ സജ്ജീകരിക്കുന്നു.
• `version`: പതിപ്പ് നൽകുന്നതിനുള്ള തന്ത്രം വ്യക്തമാക്കുന്നു. ഇത് `independent` ആകാം (ഓരോ പാക്കേജിനും അതിൻ്റേതായ പതിപ്പുണ്ട്) അല്ലെങ്കിൽ ഒരു നിശ്ചിത പതിപ്പ് ആകാം.
• `command`: `publish`, `run` പോലുള്ള നിർദ്ദിഷ്ട ലേർണ കമാൻഡുകൾക്കായി ഓപ്ഷനുകൾ ക്രമീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

`lerna.json` ഉദാഹരണം:

{
  "packages": [
    "packages/*"
  ],
  "version": "independent",
  "npmClient": "npm",
  "useWorkspaces": true,
  "command": {
    "publish": {
      "conventionalCommits": true,
      "message": "chore(release): publish"
    }
  }
}

Nx: മികച്ചതും വേഗതയേറിയതും വിപുലീകരിക്കാവുന്നതുമായ ബിൽഡ് സിസ്റ്റം

മോണോറെപ്പോ മാനേജ്മെൻ്റിനായുള്ള വിപുലമായ സവിശേഷതകൾ നൽകുന്ന ഒരു ശക്തമായ ബിൽഡ് സിസ്റ്റമാണ് Nx. ഇത് വർദ്ധിച്ചുവരുന്ന ബിൽഡുകൾ, കമ്പ്യൂട്ടേഷൻ കാഷിംഗ്, ടാസ്‌ക് ഓർക്കസ്ട്രേഷൻ എന്നിവയിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ച് ബിൽഡ് സമയവും ഡെവലപ്പർ ഉൽപ്പാദനക്ഷമതയും ഗണ്യമായി മെച്ചപ്പെടുത്തുന്നു. ലേർണ പ്രധാനമായും പാക്കേജുകൾ കൈകാര്യം ചെയ്യുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുമ്പോൾ, കോഡ് ജനറേഷൻ, ലിൻ്റിംഗ്, ടെസ്റ്റിംഗ്, വിന്യാസം എന്നിവയുൾപ്പെടെയുള്ള മുഴുവൻ മോണോറെപ്പോ വർക്ക്ഫ്ലോയും കൈകാര്യം ചെയ്യാൻ Nx കൂടുതൽ സമഗ്രമായ സമീപനം നൽകുന്നു.

Nx-ൻ്റെ പ്രധാന സവിശേഷതകൾ

• വർദ്ധിച്ചുവരുന്ന ബിൽഡുകൾ: Nx നിങ്ങളുടെ പ്രോജക്റ്റുകളുടെ ഡിപ്പൻഡൻസി ഗ്രാഫ് വിശകലനം ചെയ്യുകയും അവസാന ബിൽഡിന് ശേഷം മാറിയ പ്രോജക്റ്റുകൾ മാത്രം വീണ്ടും നിർമ്മിക്കുകയും ചെയ്യുന്നു. ഇത് ബിൽഡ് സമയം ഗണ്യമായി കുറയ്ക്കുന്നു.
• കമ്പ്യൂട്ടേഷൻ കാഷിംഗ്: Nx ബിൽഡുകൾ, ടെസ്റ്റുകൾ തുടങ്ങിയ ടാസ്‌ക്കുകളുടെ ഫലങ്ങൾ കാഷെ ചെയ്യുന്നു, അതിനാൽ ഇൻപുട്ടുകൾ മാറിയിട്ടില്ലെങ്കിൽ അവ വീണ്ടും ഉപയോഗിക്കാൻ കഴിയും. ഇത് ഡെവലപ്മെൻ്റ് സൈക്കിളുകൾ കൂടുതൽ വേഗത്തിലാക്കുന്നു.
• ടാസ്‌ക് ഓർക്കസ്ട്രേഷൻ: സങ്കീർണ്ണമായ ബിൽഡ് പൈപ്പ്ലൈനുകൾ നിർവചിക്കാനും അവ കാര്യക്ഷമമായി എക്സിക്യൂട്ട് ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്ന ശക്തമായ ടാസ്‌ക് ഓർക്കസ്ട്രേഷൻ സിസ്റ്റം Nx നൽകുന്നു.
• കോഡ് ജനറേഷൻ: മികച്ച രീതികളും സ്ഥിരമായ മാനദണ്ഡങ്ങളും പിന്തുടർന്ന് പുതിയ പ്രോജക്റ്റുകൾ, ഘടകങ്ങൾ, മൊഡ്യൂളുകൾ എന്നിവ വേഗത്തിൽ സൃഷ്ടിക്കാൻ സഹായിക്കുന്ന കോഡ് ജനറേഷൻ ടൂളുകൾ Nx നൽകുന്നു.
• പ്ലഗിൻ എക്കോസിസ്റ്റം: React, Angular, Node.js, NestJS എന്നിവയും അതിലേറെയുമുള്ള വിവിധ സാങ്കേതികവിദ്യകളെയും ചട്ടക്കൂടുകളെയും പിന്തുണയ്ക്കുന്ന ഒരു സമ്പന്നമായ പ്ലഗിൻ എക്കോസിസ്റ്റം Nx-നുണ്ട്.
• ഡിപ്പൻഡൻസി ഗ്രാഫ് വിഷ്വലൈസേഷൻ: നിങ്ങളുടെ മോണോറെപ്പോയുടെ ഡിപ്പൻഡൻസി ഗ്രാഫ് ദൃശ്യവൽക്കരിക്കാൻ Nx-ന് കഴിയും, ഇത് പ്രോജക്റ്റുകൾ തമ്മിലുള്ള ബന്ധം മനസ്സിലാക്കാനും സാധ്യമായ പ്രശ്നങ്ങൾ തിരിച്ചറിയാനും സഹായിക്കുന്നു.
• ബാധിച്ച കമാൻഡുകൾ: ഒരു പ്രത്യേക മാറ്റം ബാധിച്ച പ്രോജക്റ്റുകളിൽ മാത്രം ടാസ്‌ക്കുകൾ പ്രവർത്തിപ്പിക്കാൻ Nx കമാൻഡുകൾ നൽകുന്നു. ഇത് ശ്രദ്ധ ആവശ്യമുള്ള മേഖലകളിൽ നിങ്ങളുടെ ശ്രമങ്ങൾ കേന്ദ്രീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

Nx ഉപയോഗത്തിനുള്ള ഉദാഹരണം

ലളിതമായ ഒരു ഉദാഹരണത്തിലൂടെ Nx-ൻ്റെ ഉപയോഗം നമുക്ക് ചിത്രീകരിക്കാം. ഒരു React ആപ്ലിക്കേഷനും Node.js ലൈബ്രറിയുമുള്ള ഒരു മോണോറെപ്പോ ഞങ്ങൾ സൃഷ്ടിക്കും.

1. Nx CLI ഗ്ലോബലായി ഇൻസ്റ്റാൾ ചെയ്യുക:

npm install -g create-nx-workspace

2. ഒരു പുതിയ Nx വർക്ക്സ്പേസ് ഉണ്ടാക്കുക:

create-nx-workspace my-monorepo --preset=react
cd my-monorepo

ഇത് ഒരു React ആപ്ലിക്കേഷനുമായി ഒരു പുതിയ Nx വർക്ക്സ്പേസ് ഉണ്ടാക്കുന്നു. React-specific കോൺഫിഗറേഷനുകൾ ഉപയോഗിച്ച് വർക്ക്സ്പേസ് ആരംഭിക്കാൻ `--preset=react` ഓപ്ഷൻ Nx-നോട് പറയുന്നു.

3. ഒരു ലൈബ്രറി ഉണ്ടാക്കുക:

nx generate @nrwl/node:library my-library

ഇത് `my-library` എന്ന് പേരുള്ള ഒരു പുതിയ Node.js ലൈബ്രറി ഉണ്ടാക്കുന്നു. Nx ലൈബ്രറിയും അതിൻ്റെ ഡിപ്പൻഡൻസികളും സ്വയമേവ ക്രമീകരിക്കുന്നു.

4. ആപ്ലിക്കേഷൻ നിർമ്മിക്കുക:

nx build my-app

ഇത് React ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നു. Nx ഡിപ്പൻഡൻസി ഗ്രാഫ് വിശകലനം ചെയ്യുകയും ആവശ്യമായ ഫയലുകൾ മാത്രം വീണ്ടും നിർമ്മിക്കുകയും ചെയ്യുന്നു.

5. ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക:

nx test my-app

ഇത് React ആപ്ലിക്കേഷനായുള്ള യൂണിറ്റ് ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നു. തുടർന്നുള്ള ടെസ്റ്റ് റണ്ണുകൾ വേഗത്തിലാക്കാൻ Nx ടെസ്റ്റ് ഫലങ്ങൾ കാഷെ ചെയ്യുന്നു.

6. ഡിപ്പൻഡൻസി ഗ്രാഫ് കാണുക:

nx graph

ഇത് മോണോറെപ്പോയുടെ ഡിപ്പൻഡൻസി ഗ്രാഫ് ദൃശ്യവൽക്കരിക്കുന്ന ഒരു വെബ് ഇൻ്റർഫേസ് തുറക്കുന്നു.

Nx കോൺഫിഗറേഷൻ

വർക്ക്സ്പേസിൻ്റെ റൂട്ടിൽ സ്ഥിതി ചെയ്യുന്ന `nx.json` ഫയലിലൂടെയാണ് Nx കോൺഫിഗർ ചെയ്യുന്നത്. ഈ ഫയൽ വർക്ക്സ്പേസിലെ പ്രോജക്റ്റുകൾ, അവയുടെ ഡിപ്പൻഡൻസികൾ, അവയിൽ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുന്ന ടാസ്‌ക്കുകൾ എന്നിവ നിർവചിക്കുന്നു.

`nx.json`-ലെ പ്രധാന കോൺഫിഗറേഷൻ ഓപ്ഷനുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

• `projects`: വർക്ക്സ്പേസിലെ പ്രോജക്റ്റുകളും അവയുടെ റൂട്ട് ഡയറക്‌ടറി, ബിൽഡ് ടാർഗെറ്റുകൾ പോലുള്ള കോൺഫിഗറേഷനുകളും നിർവചിക്കുന്നു.
• `tasksRunnerOptions`: ടാസ്‌ക്കുകൾ എക്സിക്യൂട്ട് ചെയ്യാനും അവയുടെ ഫലങ്ങൾ കാഷെ ചെയ്യാനും ഉത്തരവാദിത്വമുള്ള ടാസ്‌ക് റണ്ണറെ കോൺഫിഗർ ചെയ്യുന്നു.
• `affected`: ഒരു മാറ്റം ഏതൊക്കെ പ്രോജക്റ്റുകളെ ബാധിക്കുമെന്ന് Nx എങ്ങനെ നിർണ്ണയിക്കുമെന്ന് കോൺഫിഗർ ചെയ്യുന്നു.

`nx.json` ഉദാഹരണം:

{
  "npmScope": "my-org",
  "affected": {
    "defaultBase": "main"
  },
  "implicitDependencies": {
    "package.json": {
      "dependencies": "*",
      "devDependencies": "*"
    },
    ".eslintrc.json": "*"
  },
  "tasksRunnerOptions": {
    "default": {
      "runner": "nx-cloud",
      "options": {
        "cacheableOperations": ["build", "lint", "test", "e2e"],
        "accessToken": "...",
        "canTrackAnalytics": false,
        "showUsageWarnings": false
      }
    }
  },
  "targetDefaults": {
    "build": {
      "dependsOn": ["^build"],
      "inputs": ["production", "default"],
      "outputs": ["{projectRoot}/dist"]
    }
  },
  "namedInputs": {
    "default": ["{projectRoot}/**/*", "!{projectRoot}/dist/**/*", "!{projectRoot}/tmp/**/*"],
    "production": ["!{projectRoot}/**/*.spec.ts", "!{projectRoot}/**/*.spec.tsx", "!{projectRoot}/**/*.spec.js", "!{projectRoot}/**/*.spec.jsx"]
  },
  "generators": {
    "@nrwl/react": {
      "application": {
        "style": "css",
        "linter": "eslint",
        "unitTestRunner": "jest"
      },
      "library": {
        "style": "css",
        "linter": "eslint",
        "unitTestRunner": "jest"
      },
      "component": {
        "style": "css"
      }
    },
  }
}

ലേർണ vs. Nx: ഏതാണ് തിരഞ്ഞെടുക്കേണ്ടത്?

ഫ്രണ്ടെൻഡ് മോണോറെപ്പോകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള മികച്ച ടൂളുകളാണ് ലേർണയും Nx-ഉം, എന്നാൽ അവ വ്യത്യസ്ത ആവശ്യകതകൾ നിറവേറ്റുന്നു. നിങ്ങളുടെ പ്രോജക്റ്റിന് ശരിയായത് തിരഞ്ഞെടുക്കാൻ സഹായിക്കുന്ന ഒരു താരതമ്യം ഇതാ:

സവിശേഷത	ലേർണ	Nx
ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത്	പാക്കേജ് മാനേജ്മെൻ്റ്	ബിൽഡ് സിസ്റ്റവും ടാസ്‌ക് ഓർക്കസ്ട്രേഷനും
വർദ്ധിച്ചുവരുന്ന ബിൽഡുകൾ	പരിമിതമായത് (ബാഹ്യ ടൂളുകൾ ആവശ്യമാണ്)	ബിൽറ്റ്-ഇൻ, ഉയർന്ന രീതിയിൽ ഒപ്റ്റിമൈസ് ചെയ്തത്
കമ്പ്യൂട്ടേഷൻ കാഷിംഗ്	ഇല്ല	ഉണ്ട്
കോഡ് ജനറേഷൻ	ഇല്ല	ഉണ്ട്
പ്ലഗിൻ എക്കോസിസ്റ്റം	പരിമിതമായത്	വിപുലമായത്
പഠനരീതി	കുറഞ്ഞത്	കൂടുതൽ
സങ്കീർണ്ണത	ലളിതമായത്	കൂടുതൽ സങ്കീർണ്ണം
ഉപയോഗ കേസുകൾ	പ്രധാനമായും npm പാക്കേജുകൾ കൈകാര്യം ചെയ്യുന്നതിലും പ്രസിദ്ധീകരിക്കുന്നതിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്ന പ്രോജക്റ്റുകൾ.	ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡ് സമയം, കോഡ് ജനറേഷൻ, സമഗ്രമായ ബിൽഡ് സിസ്റ്റം എന്നിവ ആവശ്യമുള്ള വലിയതും സങ്കീർണ്ണവുമായ പ്രോജക്റ്റുകൾ.

നിങ്ങൾ ലേർണ തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ:

• നിങ്ങൾക്ക് പ്രധാനമായും npm പാക്കേജുകൾ കൈകാര്യം ചെയ്യാനും പ്രസിദ്ധീകരിക്കാനും ആവശ്യമുണ്ടെങ്കിൽ.
• നിങ്ങളുടെ പ്രോജക്റ്റ് താരതമ്യേന ചെറുതോ ഇടത്തരം വലുപ്പമുള്ളതോ ആണെങ്കിൽ.
• കുറഞ്ഞ പഠനരീതിയുള്ള ലളിതമായ ഒരു ടൂൾ നിങ്ങൾ ഇഷ്ടപ്പെടുന്നെങ്കിൽ.
• നിങ്ങൾക്ക് npm-ഉം Yarn-ഉം ഇതിനകം പരിചിതമാണെങ്കിൽ.

നിങ്ങൾ Nx തിരഞ്ഞെടുക്കുകയാണെങ്കിൽ:

• നിങ്ങൾക്ക് ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡ് സമയവും വർദ്ധിച്ചുവരുന്ന ബിൽഡുകളും ആവശ്യമുണ്ടെങ്കിൽ.
• നിങ്ങൾക്ക് കോഡ് ജനറേഷൻ ശേഷികൾ വേണമെങ്കിൽ.
• ടാസ്‌ക് ഓർക്കസ്ട്രേഷനോടുകൂടിയ സമഗ്രമായ ബിൽഡ് സിസ്റ്റം നിങ്ങൾക്ക് ആവശ്യമുണ്ടെങ്കിൽ.
• നിങ്ങളുടെ പ്രോജക്റ്റ് വലുതും സങ്കീർണ്ണവുമാണെങ്കിൽ.
• കൂടുതൽ ശക്തമായ ഒരു ടൂൾ പഠിക്കാൻ നിങ്ങൾ സമയം ചെലവഴിക്കാൻ തയ്യാറാണെങ്കിൽ.

നിങ്ങൾക്ക് ലേർണ Nx-മായി ഉപയോഗിക്കാൻ കഴിയുമോ?

അതെ, ലേർണയും Nx-ഉം ഒരുമിച്ച് ഉപയോഗിക്കാൻ കഴിയും. ലേർണയുടെ പാക്കേജ് മാനേജ്മെൻ്റ് ശേഷികൾ പ്രയോജനപ്പെടുത്താനും Nx-ൻ്റെ ഒപ്റ്റിമൈസ് ചെയ്ത ബിൽഡ് സിസ്റ്റത്തിൻ്റെയും ടാസ്‌ക് ഓർക്കസ്ട്രേഷന്റെയും ഗുണങ്ങൾ നേടാനും ഈ സംയോജനം നിങ്ങളെ അനുവദിക്കുന്നു. ലേർണ കൈകാര്യം ചെയ്യുന്ന പാക്കേജുകൾക്കായി വർദ്ധിച്ചുവരുന്ന ബിൽഡുകളും കമ്പ്യൂട്ടേഷൻ കാഷിംഗും നൽകുന്ന ലേർണയുടെ ടാസ്‌ക് റണ്ണറായി Nx കോൺഫിഗർ ചെയ്യാവുന്നതാണ്.

ഫ്രണ്ടെൻഡ് മോണോറെപ്പോ മാനേജ്മെൻ്റിനായുള്ള മികച്ച രീതികൾ

നിങ്ങൾ ലേർണയോ Nx-ഓ തിരഞ്ഞെടുക്കുന്ന കാര്യത്തിൽ, ഒരു ഫ്രണ്ടെൻഡ് മോണോറെപ്പോ വിജയകരമായി കൈകാര്യം ചെയ്യുന്നതിന് മികച്ച രീതികൾ പിന്തുടരുന്നത് നിർണായകമാണ്:

• വ്യക്തമായ പ്രോജക്റ്റ് ഘടന സ്ഥാപിക്കുക: നിങ്ങളുടെ പ്രോജക്റ്റുകൾ യുക്തിപരമായും സ്ഥിരമായും ഓർഗനൈസ് ചെയ്യുക. പാക്കേജുകൾക്കും ലൈബ്രറികൾക്കും വ്യക്തമായ പേരിടൽ രീതി ഉപയോഗിക്കുക.
• സ്ഥിരമായ കോഡിംഗ് നിലവാരം നടപ്പിലാക്കുക: എല്ലാ പ്രോജക്റ്റുകളിലും സ്ഥിരമായ കോഡ് ശൈലി ഉറപ്പാക്കാൻ ലിൻ്ററുകളും ഫോർമാറ്റർമാരും ഉപയോഗിക്കുക. ESLint, Prettier പോലുള്ള ടൂളുകൾ നിങ്ങളുടെ വർക്ക്ഫ്ലോയിൽ സംയോജിപ്പിക്കാൻ കഴിയും.
• ബിൽഡ്, ടെസ്റ്റ് പ്രക്രിയകൾ ഓട്ടോമേറ്റ് ചെയ്യുക: ബിൽഡ്, ടെസ്റ്റ്, വിന്യാസ പ്രക്രിയകൾ ഓട്ടോമേറ്റ് ചെയ്യാൻ CI/CD പൈപ്പ്ലൈനുകൾ ഉപയോഗിക്കുക. Jenkins, CircleCI, GitHub Actions പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കാം.
• കോഡ് അവലോകനങ്ങൾ നടപ്പിലാക്കുക: കോഡിൻ്റെ ഗുണനിലവാരവും പരിപാലനക്ഷമതയും ഉറപ്പാക്കാൻ സമഗ്രമായ കോഡ് അവലോകനങ്ങൾ നടത്തുക. പുൾ അഭ്യർത്ഥനകളും കോഡ് അവലോകന ടൂളുകളും ഉപയോഗിക്കുക.
• ബിൽഡ് സമയവും പ്രകടനവും നിരീക്ഷിക്കുക: തടസ്സങ്ങളും മെച്ചപ്പെടുത്തലുകൾക്കുള്ള മേഖലകളും തിരിച്ചറിയാൻ ബിൽഡ് സമയവും പ്രകടന അളവുകളും ട്രാക്ക് ചെയ്യുക. ബിൽഡ് പ്രകടനം വിശകലനം ചെയ്യാൻ Nx ടൂളുകൾ നൽകുന്നു.
• നിങ്ങളുടെ മോണോറെപ്പോ ഘടനയും പ്രക്രിയകളും രേഖപ്പെടുത്തുക: നിങ്ങളുടെ മോണോറെപ്പോയുടെ ഘടന, ഉപയോഗിച്ച ടൂളുകളും സാങ്കേതികവിദ്യകളും, ഡെവലപ്മെൻ്റ് വർക്ക്ഫ്ലോകൾ എന്നിവ വിശദീകരിക്കുന്ന വ്യക്തമായ ഡോക്യുമെൻ്റേഷൻ ഉണ്ടാക്കുക.
• പരമ്പരാഗത കമ്മിറ്റുകൾ സ്വീകരിക്കുക: പതിപ്പ് നൽകുന്നതും റിലീസ് ചെയ്യുന്നതുമായ പ്രക്രിയകൾ ഓട്ടോമേറ്റ് ചെയ്യാൻ പരമ്പരാഗത കമ്മിറ്റുകൾ ഉപയോഗിക്കുക. ലേർണ പരമ്പരാഗത കമ്മിറ്റുകളെ പിന്തുണയ്ക്കുന്നു.

ഉപസംഹാരം

ഫ്രണ്ടെൻഡ് മോണോറെപ്പോകൾ കോഡ് പങ്കിടൽ, ലളിതമായ ഡിപ്പൻഡൻസി മാനേജ്മെൻ്റ്, മെച്ചപ്പെട്ട സഹകരണം എന്നിവയുൾപ്പെടെ വലിയതും സങ്കീർണ്ണവുമായ പ്രോജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിന് സുപ്രധാനമായ നേട്ടങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു. ഫ്രണ്ടെൻഡ് മോണോറെപ്പോ ഫലപ്രദമായി കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്ന ശക്തമായ ടൂളുകളാണ് ലേർണയും Nx-ഉം. npm പാക്കേജുകൾ കൈകാര്യം ചെയ്യുന്നതിന് ലേർണ ഒരു മികച്ച ചോയിസാണ്, അതേസമയം Nx വർദ്ധിച്ചുവരുന്ന ബിൽഡുകളും കോഡ് ജനറേഷനും പോലുള്ള വിപുലമായ സവിശേഷതകളുള്ള കൂടുതൽ സമഗ്രമായ ബിൽഡ് സിസ്റ്റം നൽകുന്നു. നിങ്ങളുടെ പ്രോജക്റ്റിൻ്റെ ആവശ്യകതകൾ ശ്രദ്ധാപൂർവ്വം പരിഗണിച്ച് മികച്ച രീതികൾ പിന്തുടരുന്നതിലൂടെ, നിങ്ങൾക്ക് ഒരു ഫ്രണ്ടെൻഡ് മോണോറെപ്പോ വിജയകരമായി സ്വീകരിക്കാനും അതിൻ്റെ ആനുകൂല്യങ്ങൾ നേടാനും കഴിയും.

ലേർണയും Nx-ഉം തമ്മിൽ തിരഞ്ഞെടുക്കുമ്പോൾ നിങ്ങളുടെ ടീമിൻ്റെ അനുഭവം, പ്രോജക്റ്റ് സങ്കീർണ്ണത, പ്രകടന ആവശ്യകതകൾ തുടങ്ങിയ ഘടകങ്ങൾ പരിഗണിക്കാൻ ഓർക്കുക. രണ്ട് ടൂളുകളും പരീക്ഷിക്കുകയും നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്ക് ഏറ്റവും അനുയോജ്യമായത് കണ്ടെത്തുകയും ചെയ്യുക.

നിങ്ങളുടെ മോണോറെപ്പോ യാത്രയ്ക്ക് എല്ലാ ആശംസകളും!